// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: src/carnot/planner/dynamic_tracing/ir/logicalpb/logical.proto

package logicalpb

import (
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
	types "github.com/gogo/protobuf/types"
	io "io"
	math "math"
	math_bits "math/bits"
	reflect "reflect"
	strconv "strconv"
	strings "strings"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

type SelectorType int32

const (
	NO_CONDITION SelectorType = 0
	MAX_KERNEL   SelectorType = 1
	MIN_KERNEL   SelectorType = 2
	HOST_NAME    SelectorType = 3
)

var SelectorType_name = map[int32]string{
	0: "NO_CONDITION",
	1: "MAX_KERNEL",
	2: "MIN_KERNEL",
	3: "HOST_NAME",
}

var SelectorType_value = map[string]int32{
	"NO_CONDITION": 0,
	"MAX_KERNEL":   1,
	"MIN_KERNEL":   2,
	"HOST_NAME":    3,
}

func (SelectorType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8cf202d4a324913e, []int{0}
}

type Argument struct {
	Id   string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Expr string `protobuf:"bytes,2,opt,name=expr,proto3" json:"expr,omitempty"`
}

func (m *Argument) Reset()      { *m = Argument{} }
func (*Argument) ProtoMessage() {}
func (*Argument) Descriptor() ([]byte, []int) {
	return fileDescriptor_8cf202d4a324913e, []int{0}
}
func (m *Argument) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Argument) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Argument.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Argument) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Argument.Merge(m, src)
}
func (m *Argument) XXX_Size() int {
	return m.Size()
}
func (m *Argument) XXX_DiscardUnknown() {
	xxx_messageInfo_Argument.DiscardUnknown(m)
}

var xxx_messageInfo_Argument proto.InternalMessageInfo

func (m *Argument) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *Argument) GetExpr() string {
	if m != nil {
		return m.Expr
	}
	return ""
}

type ReturnValue struct {
	Id   string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Expr string `protobuf:"bytes,2,opt,name=expr,proto3" json:"expr,omitempty"`
}

func (m *ReturnValue) Reset()      { *m = ReturnValue{} }
func (*ReturnValue) ProtoMessage() {}
func (*ReturnValue) Descriptor() ([]byte, []int) {
	return fileDescriptor_8cf202d4a324913e, []int{1}
}
func (m *ReturnValue) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ReturnValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ReturnValue.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ReturnValue) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReturnValue.Merge(m, src)
}
func (m *ReturnValue) XXX_Size() int {
	return m.Size()
}
func (m *ReturnValue) XXX_DiscardUnknown() {
	xxx_messageInfo_ReturnValue.DiscardUnknown(m)
}

var xxx_messageInfo_ReturnValue proto.InternalMessageInfo

func (m *ReturnValue) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *ReturnValue) GetExpr() string {
	if m != nil {
		return m.Expr
	}
	return ""
}

type Output struct {
	Name   string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Fields []string `protobuf:"bytes,2,rep,name=fields,proto3" json:"fields,omitempty"`
}

func (m *Output) Reset()      { *m = Output{} }
func (*Output) ProtoMessage() {}
func (*Output) Descriptor() ([]byte, []int) {
	return fileDescriptor_8cf202d4a324913e, []int{2}
}
func (m *Output) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Output) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Output.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Output) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Output.Merge(m, src)
}
func (m *Output) XXX_Size() int {
	return m.Size()
}
func (m *Output) XXX_DiscardUnknown() {
	xxx_messageInfo_Output.DiscardUnknown(m)
}

var xxx_messageInfo_Output proto.InternalMessageInfo

func (m *Output) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *Output) GetFields() []string {
	if m != nil {
		return m.Fields
	}
	return nil
}

type OutputAction struct {
	OutputName    string   `protobuf:"bytes,1,opt,name=output_name,json=outputName,proto3" json:"output_name,omitempty"`
	VariableNames []string `protobuf:"bytes,2,rep,name=variable_names,json=variableNames,proto3" json:"variable_names,omitempty"`
}

func (m *OutputAction) Reset()      { *m = OutputAction{} }
func (*OutputAction) ProtoMessage() {}
func (*OutputAction) Descriptor() ([]byte, []int) {
	return fileDescriptor_8cf202d4a324913e, []int{3}
}
func (m *OutputAction) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *OutputAction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_OutputAction.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *OutputAction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OutputAction.Merge(m, src)
}
func (m *OutputAction) XXX_Size() int {
	return m.Size()
}
func (m *OutputAction) XXX_DiscardUnknown() {
	xxx_messageInfo_OutputAction.DiscardUnknown(m)
}

var xxx_messageInfo_OutputAction proto.InternalMessageInfo

func (m *OutputAction) GetOutputName() string {
	if m != nil {
		return m.OutputName
	}
	return ""
}

func (m *OutputAction) GetVariableNames() []string {
	if m != nil {
		return m.VariableNames
	}
	return nil
}

type Tracepoint struct {
	Symbol string `protobuf:"bytes,1,opt,name=symbol,proto3" json:"symbol,omitempty"`
}

func (m *Tracepoint) Reset()      { *m = Tracepoint{} }
func (*Tracepoint) ProtoMessage() {}
func (*Tracepoint) Descriptor() ([]byte, []int) {
	return fileDescriptor_8cf202d4a324913e, []int{4}
}
func (m *Tracepoint) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Tracepoint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Tracepoint.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Tracepoint) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Tracepoint.Merge(m, src)
}
func (m *Tracepoint) XXX_Size() int {
	return m.Size()
}
func (m *Tracepoint) XXX_DiscardUnknown() {
	xxx_messageInfo_Tracepoint.DiscardUnknown(m)
}

var xxx_messageInfo_Tracepoint proto.InternalMessageInfo

func (m *Tracepoint) GetSymbol() string {
	if m != nil {
		return m.Symbol
	}
	return ""
}

type FunctionLatency struct {
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
}

func (m *FunctionLatency) Reset()      { *m = FunctionLatency{} }
func (*FunctionLatency) ProtoMessage() {}
func (*FunctionLatency) Descriptor() ([]byte, []int) {
	return fileDescriptor_8cf202d4a324913e, []int{5}
}
func (m *FunctionLatency) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FunctionLatency) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FunctionLatency.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *FunctionLatency) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FunctionLatency.Merge(m, src)
}
func (m *FunctionLatency) XXX_Size() int {
	return m.Size()
}
func (m *FunctionLatency) XXX_DiscardUnknown() {
	xxx_messageInfo_FunctionLatency.DiscardUnknown(m)
}

var xxx_messageInfo_FunctionLatency proto.InternalMessageInfo

func (m *FunctionLatency) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

type Probe struct {
	Name       string         `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Tracepoint *Tracepoint    `protobuf:"bytes,2,opt,name=tracepoint,proto3" json:"tracepoint,omitempty"`
	Args       []*Argument    `protobuf:"bytes,3,rep,name=args,proto3" json:"args,omitempty"`
	RetVals    []*ReturnValue `protobuf:"bytes,4,rep,name=ret_vals,json=retVals,proto3" json:"ret_vals,omitempty"`
	// Types that are valid to be assigned to FunctionLatencyOneof:
	//
	//	*Probe_FunctionLatency
	FunctionLatencyOneof isProbe_FunctionLatencyOneof `protobuf_oneof:"function_latency_oneof"`
	OutputActions        []*OutputAction              `protobuf:"bytes,6,rep,name=output_actions,json=outputActions,proto3" json:"output_actions,omitempty"`
}

func (m *Probe) Reset()      { *m = Probe{} }
func (*Probe) ProtoMessage() {}
func (*Probe) Descriptor() ([]byte, []int) {
	return fileDescriptor_8cf202d4a324913e, []int{6}
}
func (m *Probe) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Probe) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Probe.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Probe) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Probe.Merge(m, src)
}
func (m *Probe) XXX_Size() int {
	return m.Size()
}
func (m *Probe) XXX_DiscardUnknown() {
	xxx_messageInfo_Probe.DiscardUnknown(m)
}

var xxx_messageInfo_Probe proto.InternalMessageInfo

type isProbe_FunctionLatencyOneof interface {
	isProbe_FunctionLatencyOneof()
	Equal(interface{}) bool
	MarshalTo([]byte) (int, error)
	Size() int
}

type Probe_FunctionLatency struct {
	FunctionLatency *FunctionLatency `protobuf:"bytes,5,opt,name=function_latency,json=functionLatency,proto3,oneof" json:"function_latency,omitempty"`
}

func (*Probe_FunctionLatency) isProbe_FunctionLatencyOneof() {}

func (m *Probe) GetFunctionLatencyOneof() isProbe_FunctionLatencyOneof {
	if m != nil {
		return m.FunctionLatencyOneof
	}
	return nil
}

func (m *Probe) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *Probe) GetTracepoint() *Tracepoint {
	if m != nil {
		return m.Tracepoint
	}
	return nil
}

func (m *Probe) GetArgs() []*Argument {
	if m != nil {
		return m.Args
	}
	return nil
}

func (m *Probe) GetRetVals() []*ReturnValue {
	if m != nil {
		return m.RetVals
	}
	return nil
}

func (m *Probe) GetFunctionLatency() *FunctionLatency {
	if x, ok := m.GetFunctionLatencyOneof().(*Probe_FunctionLatency); ok {
		return x.FunctionLatency
	}
	return nil
}

func (m *Probe) GetOutputActions() []*OutputAction {
	if m != nil {
		return m.OutputActions
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Probe) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Probe_FunctionLatency)(nil),
	}
}

type TracepointSpec struct {
	Outputs []*Output `protobuf:"bytes,1,rep,name=outputs,proto3" json:"outputs,omitempty"`
	Probe   *Probe    `protobuf:"bytes,2,opt,name=probe,proto3" json:"probe,omitempty"`
}

func (m *TracepointSpec) Reset()      { *m = TracepointSpec{} }
func (*TracepointSpec) ProtoMessage() {}
func (*TracepointSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_8cf202d4a324913e, []int{7}
}
func (m *TracepointSpec) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TracepointSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TracepointSpec.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TracepointSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TracepointSpec.Merge(m, src)
}
func (m *TracepointSpec) XXX_Size() int {
	return m.Size()
}
func (m *TracepointSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_TracepointSpec.DiscardUnknown(m)
}

var xxx_messageInfo_TracepointSpec proto.InternalMessageInfo

func (m *TracepointSpec) GetOutputs() []*Output {
	if m != nil {
		return m.Outputs
	}
	return nil
}

func (m *TracepointSpec) GetProbe() *Probe {
	if m != nil {
		return m.Probe
	}
	return nil
}

type BPFTrace struct {
	Program string `protobuf:"bytes,1,opt,name=program,proto3" json:"program,omitempty"`
}

func (m *BPFTrace) Reset()      { *m = BPFTrace{} }
func (*BPFTrace) ProtoMessage() {}
func (*BPFTrace) Descriptor() ([]byte, []int) {
	return fileDescriptor_8cf202d4a324913e, []int{8}
}
func (m *BPFTrace) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BPFTrace) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BPFTrace.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *BPFTrace) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BPFTrace.Merge(m, src)
}
func (m *BPFTrace) XXX_Size() int {
	return m.Size()
}
func (m *BPFTrace) XXX_DiscardUnknown() {
	xxx_messageInfo_BPFTrace.DiscardUnknown(m)
}

var xxx_messageInfo_BPFTrace proto.InternalMessageInfo

func (m *BPFTrace) GetProgram() string {
	if m != nil {
		return m.Program
	}
	return ""
}

type UPID struct {
	Asid uint32 `protobuf:"varint,1,opt,name=asid,proto3" json:"asid,omitempty"`
	Pid  uint32 `protobuf:"varint,2,opt,name=pid,proto3" json:"pid,omitempty"`
	TsNs uint64 `protobuf:"varint,3,opt,name=ts_ns,json=tsNs,proto3" json:"ts_ns,omitempty"`
}

func (m *UPID) Reset()      { *m = UPID{} }
func (*UPID) ProtoMessage() {}
func (*UPID) Descriptor() ([]byte, []int) {
	return fileDescriptor_8cf202d4a324913e, []int{9}
}
func (m *UPID) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UPID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UPID.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *UPID) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UPID.Merge(m, src)
}
func (m *UPID) XXX_Size() int {
	return m.Size()
}
func (m *UPID) XXX_DiscardUnknown() {
	xxx_messageInfo_UPID.DiscardUnknown(m)
}

var xxx_messageInfo_UPID proto.InternalMessageInfo

func (m *UPID) GetAsid() uint32 {
	if m != nil {
		return m.Asid
	}
	return 0
}

func (m *UPID) GetPid() uint32 {
	if m != nil {
		return m.Pid
	}
	return 0
}

func (m *UPID) GetTsNs() uint64 {
	if m != nil {
		return m.TsNs
	}
	return 0
}

type DeploymentSpec struct {
	// Types that are valid to be assigned to TargetOneof:
	//
	//	*DeploymentSpec_Upid
	//	*DeploymentSpec_SharedObject_
	//	*DeploymentSpec_PodProcess_
	//	*DeploymentSpec_LabelSelector_
	TargetOneof isDeploymentSpec_TargetOneof `protobuf_oneof:"target_oneof"`
}

func (m *DeploymentSpec) Reset()      { *m = DeploymentSpec{} }
func (*DeploymentSpec) ProtoMessage() {}
func (*DeploymentSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_8cf202d4a324913e, []int{10}
}
func (m *DeploymentSpec) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DeploymentSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DeploymentSpec.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DeploymentSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeploymentSpec.Merge(m, src)
}
func (m *DeploymentSpec) XXX_Size() int {
	return m.Size()
}
func (m *DeploymentSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_DeploymentSpec.DiscardUnknown(m)
}

var xxx_messageInfo_DeploymentSpec proto.InternalMessageInfo

type isDeploymentSpec_TargetOneof interface {
	isDeploymentSpec_TargetOneof()
	Equal(interface{}) bool
	MarshalTo([]byte) (int, error)
	Size() int
}

type DeploymentSpec_Upid struct {
	Upid *UPID `protobuf:"bytes,1,opt,name=upid,proto3,oneof" json:"upid,omitempty"`
}
type DeploymentSpec_SharedObject_ struct {
	SharedObject *DeploymentSpec_SharedObject `protobuf:"bytes,2,opt,name=shared_object,json=sharedObject,proto3,oneof" json:"shared_object,omitempty"`
}
type DeploymentSpec_PodProcess_ struct {
	PodProcess *DeploymentSpec_PodProcess `protobuf:"bytes,3,opt,name=pod_process,json=podProcess,proto3,oneof" json:"pod_process,omitempty"`
}
type DeploymentSpec_LabelSelector_ struct {
	LabelSelector *DeploymentSpec_LabelSelector `protobuf:"bytes,4,opt,name=label_selector,json=labelSelector,proto3,oneof" json:"label_selector,omitempty"`
}

func (*DeploymentSpec_Upid) isDeploymentSpec_TargetOneof()           {}
func (*DeploymentSpec_SharedObject_) isDeploymentSpec_TargetOneof()  {}
func (*DeploymentSpec_PodProcess_) isDeploymentSpec_TargetOneof()    {}
func (*DeploymentSpec_LabelSelector_) isDeploymentSpec_TargetOneof() {}

func (m *DeploymentSpec) GetTargetOneof() isDeploymentSpec_TargetOneof {
	if m != nil {
		return m.TargetOneof
	}
	return nil
}

func (m *DeploymentSpec) GetUpid() *UPID {
	if x, ok := m.GetTargetOneof().(*DeploymentSpec_Upid); ok {
		return x.Upid
	}
	return nil
}

func (m *DeploymentSpec) GetSharedObject() *DeploymentSpec_SharedObject {
	if x, ok := m.GetTargetOneof().(*DeploymentSpec_SharedObject_); ok {
		return x.SharedObject
	}
	return nil
}

func (m *DeploymentSpec) GetPodProcess() *DeploymentSpec_PodProcess {
	if x, ok := m.GetTargetOneof().(*DeploymentSpec_PodProcess_); ok {
		return x.PodProcess
	}
	return nil
}

func (m *DeploymentSpec) GetLabelSelector() *DeploymentSpec_LabelSelector {
	if x, ok := m.GetTargetOneof().(*DeploymentSpec_LabelSelector_); ok {
		return x.LabelSelector
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*DeploymentSpec) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*DeploymentSpec_Upid)(nil),
		(*DeploymentSpec_SharedObject_)(nil),
		(*DeploymentSpec_PodProcess_)(nil),
		(*DeploymentSpec_LabelSelector_)(nil),
	}
}

type DeploymentSpec_SharedObject struct {
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Upid *UPID  `protobuf:"bytes,2,opt,name=upid,proto3" json:"upid,omitempty"`
}

func (m *DeploymentSpec_SharedObject) Reset()      { *m = DeploymentSpec_SharedObject{} }
func (*DeploymentSpec_SharedObject) ProtoMessage() {}
func (*DeploymentSpec_SharedObject) Descriptor() ([]byte, []int) {
	return fileDescriptor_8cf202d4a324913e, []int{10, 0}
}
func (m *DeploymentSpec_SharedObject) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DeploymentSpec_SharedObject) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DeploymentSpec_SharedObject.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DeploymentSpec_SharedObject) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeploymentSpec_SharedObject.Merge(m, src)
}
func (m *DeploymentSpec_SharedObject) XXX_Size() int {
	return m.Size()
}
func (m *DeploymentSpec_SharedObject) XXX_DiscardUnknown() {
	xxx_messageInfo_DeploymentSpec_SharedObject.DiscardUnknown(m)
}

var xxx_messageInfo_DeploymentSpec_SharedObject proto.InternalMessageInfo

func (m *DeploymentSpec_SharedObject) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *DeploymentSpec_SharedObject) GetUpid() *UPID {
	if m != nil {
		return m.Upid
	}
	return nil
}

type DeploymentSpec_PodProcess struct {
	Pods      []string `protobuf:"bytes,1,rep,name=pods,proto3" json:"pods,omitempty"`
	Container string   `protobuf:"bytes,2,opt,name=container,proto3" json:"container,omitempty"`
	Process   string   `protobuf:"bytes,3,opt,name=process,proto3" json:"process,omitempty"`
}

func (m *DeploymentSpec_PodProcess) Reset()      { *m = DeploymentSpec_PodProcess{} }
func (*DeploymentSpec_PodProcess) ProtoMessage() {}
func (*DeploymentSpec_PodProcess) Descriptor() ([]byte, []int) {
	return fileDescriptor_8cf202d4a324913e, []int{10, 1}
}
func (m *DeploymentSpec_PodProcess) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DeploymentSpec_PodProcess) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DeploymentSpec_PodProcess.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DeploymentSpec_PodProcess) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeploymentSpec_PodProcess.Merge(m, src)
}
func (m *DeploymentSpec_PodProcess) XXX_Size() int {
	return m.Size()
}
func (m *DeploymentSpec_PodProcess) XXX_DiscardUnknown() {
	xxx_messageInfo_DeploymentSpec_PodProcess.DiscardUnknown(m)
}

var xxx_messageInfo_DeploymentSpec_PodProcess proto.InternalMessageInfo

func (m *DeploymentSpec_PodProcess) GetPods() []string {
	if m != nil {
		return m.Pods
	}
	return nil
}

func (m *DeploymentSpec_PodProcess) GetContainer() string {
	if m != nil {
		return m.Container
	}
	return ""
}

func (m *DeploymentSpec_PodProcess) GetProcess() string {
	if m != nil {
		return m.Process
	}
	return ""
}

type DeploymentSpec_LabelSelector struct {
	Labels    map[string]string `protobuf:"bytes,1,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Namespace string            `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	Container string            `protobuf:"bytes,3,opt,name=container,proto3" json:"container,omitempty"`
	Process   string            `protobuf:"bytes,4,opt,name=process,proto3" json:"process,omitempty"`
}

func (m *DeploymentSpec_LabelSelector) Reset()      { *m = DeploymentSpec_LabelSelector{} }
func (*DeploymentSpec_LabelSelector) ProtoMessage() {}
func (*DeploymentSpec_LabelSelector) Descriptor() ([]byte, []int) {
	return fileDescriptor_8cf202d4a324913e, []int{10, 2}
}
func (m *DeploymentSpec_LabelSelector) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DeploymentSpec_LabelSelector) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DeploymentSpec_LabelSelector.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DeploymentSpec_LabelSelector) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeploymentSpec_LabelSelector.Merge(m, src)
}
func (m *DeploymentSpec_LabelSelector) XXX_Size() int {
	return m.Size()
}
func (m *DeploymentSpec_LabelSelector) XXX_DiscardUnknown() {
	xxx_messageInfo_DeploymentSpec_LabelSelector.DiscardUnknown(m)
}

var xxx_messageInfo_DeploymentSpec_LabelSelector proto.InternalMessageInfo

func (m *DeploymentSpec_LabelSelector) GetLabels() map[string]string {
	if m != nil {
		return m.Labels
	}
	return nil
}

func (m *DeploymentSpec_LabelSelector) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

func (m *DeploymentSpec_LabelSelector) GetContainer() string {
	if m != nil {
		return m.Container
	}
	return ""
}

func (m *DeploymentSpec_LabelSelector) GetProcess() string {
	if m != nil {
		return m.Process
	}
	return ""
}

type TracepointSelector struct {
	SelectorType SelectorType `protobuf:"varint,1,opt,name=selector_type,json=selectorType,proto3,enum=px.carnot.planner.dynamic_tracing.ir.logical.SelectorType" json:"selector_type,omitempty"`
	Value        string       `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
}

func (m *TracepointSelector) Reset()      { *m = TracepointSelector{} }
func (*TracepointSelector) ProtoMessage() {}
func (*TracepointSelector) Descriptor() ([]byte, []int) {
	return fileDescriptor_8cf202d4a324913e, []int{11}
}
func (m *TracepointSelector) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TracepointSelector) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TracepointSelector.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TracepointSelector) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TracepointSelector.Merge(m, src)
}
func (m *TracepointSelector) XXX_Size() int {
	return m.Size()
}
func (m *TracepointSelector) XXX_DiscardUnknown() {
	xxx_messageInfo_TracepointSelector.DiscardUnknown(m)
}

var xxx_messageInfo_TracepointSelector proto.InternalMessageInfo

func (m *TracepointSelector) GetSelectorType() SelectorType {
	if m != nil {
		return m.SelectorType
	}
	return NO_CONDITION
}

func (m *TracepointSelector) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type TracepointDeployment struct {
	Name           string                                    `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	TTL            *types.Duration                           `protobuf:"bytes,2,opt,name=ttl,proto3" json:"ttl,omitempty"`
	DeploymentSpec *DeploymentSpec                           `protobuf:"bytes,3,opt,name=deployment_spec,json=deploymentSpec,proto3" json:"deployment_spec,omitempty"`
	Programs       []*TracepointDeployment_TracepointProgram `protobuf:"bytes,4,rep,name=programs,proto3" json:"programs,omitempty"`
}

func (m *TracepointDeployment) Reset()      { *m = TracepointDeployment{} }
func (*TracepointDeployment) ProtoMessage() {}
func (*TracepointDeployment) Descriptor() ([]byte, []int) {
	return fileDescriptor_8cf202d4a324913e, []int{12}
}
func (m *TracepointDeployment) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TracepointDeployment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TracepointDeployment.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TracepointDeployment) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TracepointDeployment.Merge(m, src)
}
func (m *TracepointDeployment) XXX_Size() int {
	return m.Size()
}
func (m *TracepointDeployment) XXX_DiscardUnknown() {
	xxx_messageInfo_TracepointDeployment.DiscardUnknown(m)
}

var xxx_messageInfo_TracepointDeployment proto.InternalMessageInfo

func (m *TracepointDeployment) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *TracepointDeployment) GetTTL() *types.Duration {
	if m != nil {
		return m.TTL
	}
	return nil
}

func (m *TracepointDeployment) GetDeploymentSpec() *DeploymentSpec {
	if m != nil {
		return m.DeploymentSpec
	}
	return nil
}

func (m *TracepointDeployment) GetPrograms() []*TracepointDeployment_TracepointProgram {
	if m != nil {
		return m.Programs
	}
	return nil
}

type TracepointDeployment_TracepointProgram struct {
	TableName string                `protobuf:"bytes,1,opt,name=table_name,json=tableName,proto3" json:"table_name,omitempty"`
	Spec      *TracepointSpec       `protobuf:"bytes,2,opt,name=spec,proto3" json:"spec,omitempty"`
	BPFTrace  *BPFTrace             `protobuf:"bytes,3,opt,name=bpftrace,proto3" json:"bpftrace,omitempty"`
	Selectors []*TracepointSelector `protobuf:"bytes,4,rep,name=selectors,proto3" json:"selectors,omitempty"`
}

func (m *TracepointDeployment_TracepointProgram) Reset() {
	*m = TracepointDeployment_TracepointProgram{}
}
func (*TracepointDeployment_TracepointProgram) ProtoMessage() {}
func (*TracepointDeployment_TracepointProgram) Descriptor() ([]byte, []int) {
	return fileDescriptor_8cf202d4a324913e, []int{12, 0}
}
func (m *TracepointDeployment_TracepointProgram) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TracepointDeployment_TracepointProgram) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TracepointDeployment_TracepointProgram.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TracepointDeployment_TracepointProgram) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TracepointDeployment_TracepointProgram.Merge(m, src)
}
func (m *TracepointDeployment_TracepointProgram) XXX_Size() int {
	return m.Size()
}
func (m *TracepointDeployment_TracepointProgram) XXX_DiscardUnknown() {
	xxx_messageInfo_TracepointDeployment_TracepointProgram.DiscardUnknown(m)
}

var xxx_messageInfo_TracepointDeployment_TracepointProgram proto.InternalMessageInfo

func (m *TracepointDeployment_TracepointProgram) GetTableName() string {
	if m != nil {
		return m.TableName
	}
	return ""
}

func (m *TracepointDeployment_TracepointProgram) GetSpec() *TracepointSpec {
	if m != nil {
		return m.Spec
	}
	return nil
}

func (m *TracepointDeployment_TracepointProgram) GetBPFTrace() *BPFTrace {
	if m != nil {
		return m.BPFTrace
	}
	return nil
}

func (m *TracepointDeployment_TracepointProgram) GetSelectors() []*TracepointSelector {
	if m != nil {
		return m.Selectors
	}
	return nil
}

func init() {
	proto.RegisterEnum("px.carnot.planner.dynamic_tracing.ir.logical.SelectorType", SelectorType_name, SelectorType_value)
	proto.RegisterType((*Argument)(nil), "px.carnot.planner.dynamic_tracing.ir.logical.Argument")
	proto.RegisterType((*ReturnValue)(nil), "px.carnot.planner.dynamic_tracing.ir.logical.ReturnValue")
	proto.RegisterType((*Output)(nil), "px.carnot.planner.dynamic_tracing.ir.logical.Output")
	proto.RegisterType((*OutputAction)(nil), "px.carnot.planner.dynamic_tracing.ir.logical.OutputAction")
	proto.RegisterType((*Tracepoint)(nil), "px.carnot.planner.dynamic_tracing.ir.logical.Tracepoint")
	proto.RegisterType((*FunctionLatency)(nil), "px.carnot.planner.dynamic_tracing.ir.logical.FunctionLatency")
	proto.RegisterType((*Probe)(nil), "px.carnot.planner.dynamic_tracing.ir.logical.Probe")
	proto.RegisterType((*TracepointSpec)(nil), "px.carnot.planner.dynamic_tracing.ir.logical.TracepointSpec")
	proto.RegisterType((*BPFTrace)(nil), "px.carnot.planner.dynamic_tracing.ir.logical.BPFTrace")
	proto.RegisterType((*UPID)(nil), "px.carnot.planner.dynamic_tracing.ir.logical.UPID")
	proto.RegisterType((*DeploymentSpec)(nil), "px.carnot.planner.dynamic_tracing.ir.logical.DeploymentSpec")
	proto.RegisterType((*DeploymentSpec_SharedObject)(nil), "px.carnot.planner.dynamic_tracing.ir.logical.DeploymentSpec.SharedObject")
	proto.RegisterType((*DeploymentSpec_PodProcess)(nil), "px.carnot.planner.dynamic_tracing.ir.logical.DeploymentSpec.PodProcess")
	proto.RegisterType((*DeploymentSpec_LabelSelector)(nil), "px.carnot.planner.dynamic_tracing.ir.logical.DeploymentSpec.LabelSelector")
	proto.RegisterMapType((map[string]string)(nil), "px.carnot.planner.dynamic_tracing.ir.logical.DeploymentSpec.LabelSelector.LabelsEntry")
	proto.RegisterType((*TracepointSelector)(nil), "px.carnot.planner.dynamic_tracing.ir.logical.TracepointSelector")
	proto.RegisterType((*TracepointDeployment)(nil), "px.carnot.planner.dynamic_tracing.ir.logical.TracepointDeployment")
	proto.RegisterType((*TracepointDeployment_TracepointProgram)(nil), "px.carnot.planner.dynamic_tracing.ir.logical.TracepointDeployment.TracepointProgram")
}

func init() {
	proto.RegisterFile("src/carnot/planner/dynamic_tracing/ir/logicalpb/logical.proto", fileDescriptor_8cf202d4a324913e)
}

var fileDescriptor_8cf202d4a324913e = []byte{
	// 1153 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0x4d, 0x8f, 0xdb, 0xc4,
	0x1b, 0xb7, 0x93, 0xec, 0x4b, 0x9e, 0xbc, 0x74, 0xff, 0xf3, 0xaf, 0xaa, 0x10, 0x81, 0x5b, 0xa2,
	0x22, 0xad, 0x10, 0x38, 0x62, 0x5b, 0xa1, 0xb6, 0xa2, 0x82, 0x0d, 0xbb, 0x25, 0x29, 0xdb, 0x24,
	0x9a, 0x0d, 0xab, 0x8a, 0x03, 0x66, 0x62, 0x4f, 0x52, 0x2f, 0x8e, 0x67, 0x34, 0x9e, 0x54, 0xcd,
	0xad, 0xe2, 0xca, 0xa5, 0x27, 0x3e, 0x03, 0x12, 0xdf, 0x03, 0x71, 0xec, 0xb1, 0xa7, 0x8a, 0xa6,
	0x17, 0x8e, 0xfd, 0x08, 0xc8, 0xe3, 0x71, 0xe2, 0x2c, 0x2b, 0x44, 0xb6, 0xdc, 0xe6, 0xf7, 0x78,
	0xe6, 0xf7, 0xbc, 0xfd, 0xe6, 0xc5, 0x70, 0x37, 0x12, 0x6e, 0xd3, 0x25, 0x22, 0x64, 0xb2, 0xc9,
	0x03, 0x12, 0x86, 0x54, 0x34, 0xbd, 0x59, 0x48, 0x26, 0xbe, 0xeb, 0x48, 0x41, 0x5c, 0x3f, 0x1c,
	0x37, 0x7d, 0xd1, 0x0c, 0xd8, 0xd8, 0x77, 0x49, 0xc0, 0x87, 0xe9, 0xc8, 0xe6, 0x82, 0x49, 0x86,
	0x3e, 0xe2, 0x4f, 0xec, 0x64, 0xb5, 0xad, 0x57, 0xdb, 0x67, 0x56, 0xdb, 0xbe, 0xb0, 0xf5, 0x9a,
	0xfa, 0xc7, 0x63, 0x5f, 0x3e, 0x9a, 0x0e, 0x6d, 0x97, 0x4d, 0x9a, 0x63, 0x36, 0x66, 0x4d, 0x45,
	0x32, 0x9c, 0x8e, 0x14, 0x52, 0x40, 0x8d, 0x12, 0xf2, 0xba, 0x35, 0x66, 0x6c, 0x1c, 0xd0, 0xe5,
	0x2c, 0x6f, 0x2a, 0x88, 0xf4, 0x59, 0x98, 0x7c, 0x6f, 0xd8, 0xb0, 0xbd, 0x2f, 0xc6, 0xd3, 0x09,
	0x0d, 0x25, 0xaa, 0x42, 0xce, 0xf7, 0x6a, 0xe6, 0x35, 0x73, 0xb7, 0x88, 0x73, 0xbe, 0x87, 0x10,
	0x14, 0xe8, 0x13, 0x2e, 0x6a, 0x39, 0x65, 0x51, 0xe3, 0xc6, 0x27, 0x50, 0xc2, 0x54, 0x4e, 0x45,
	0x78, 0x42, 0x82, 0x29, 0xfd, 0x57, 0x4b, 0x6e, 0xc2, 0x66, 0x6f, 0x2a, 0xf9, 0x54, 0xc6, 0x5f,
	0x43, 0x32, 0xa1, 0x7a, 0xbe, 0x1a, 0xa3, 0x2b, 0xb0, 0x39, 0xf2, 0x69, 0xe0, 0x45, 0xb5, 0xdc,
	0xb5, 0xfc, 0x6e, 0x11, 0x6b, 0xd4, 0x38, 0x81, 0x72, 0xb2, 0x6a, 0xdf, 0x8d, 0xc3, 0x45, 0x57,
	0xa1, 0xc4, 0x14, 0x76, 0x32, 0x14, 0x90, 0x98, 0xba, 0x31, 0xd1, 0x07, 0x50, 0x7d, 0x4c, 0x84,
	0x4f, 0x86, 0x01, 0x55, 0x53, 0x52, 0xc2, 0x4a, 0x6a, 0x8d, 0x67, 0x45, 0x8d, 0xeb, 0x00, 0x03,
	0x41, 0x5c, 0xca, 0x99, 0x1f, 0xca, 0xd8, 0x7b, 0x34, 0x9b, 0x0c, 0x59, 0xa0, 0x09, 0x35, 0x6a,
	0xbc, 0x0f, 0x97, 0xee, 0x4d, 0x43, 0xe5, 0xf9, 0x88, 0x48, 0x1a, 0xba, 0xb3, 0xb3, 0xa9, 0x36,
	0x9e, 0x16, 0x60, 0xa3, 0x2f, 0xd8, 0x90, 0x9e, 0x9b, 0xd6, 0x43, 0x00, 0xb9, 0x70, 0xa3, 0xca,
	0x51, 0xda, 0xbb, 0x65, 0xaf, 0xd3, 0x69, 0x7b, 0x19, 0x26, 0xce, 0x70, 0xa1, 0xfb, 0x50, 0x20,
	0x62, 0x1c, 0xd5, 0xf2, 0xd7, 0xf2, 0xbb, 0xa5, 0xbd, 0x4f, 0xd7, 0xe3, 0x4c, 0x7b, 0x8d, 0x15,
	0x07, 0x1a, 0xc0, 0xb6, 0xa0, 0xd2, 0x79, 0x4c, 0x82, 0xa8, 0x56, 0x50, 0x7c, 0xb7, 0xd7, 0xe3,
	0xcb, 0x68, 0x01, 0x6f, 0x09, 0x2a, 0x4f, 0x48, 0x10, 0xa1, 0x53, 0xd8, 0x19, 0xe9, 0xe2, 0x39,
	0x41, 0x52, 0xbd, 0xda, 0x86, 0xaa, 0xc0, 0xdd, 0xf5, 0xd8, 0xcf, 0xb4, 0xa0, 0x6d, 0xe0, 0x4b,
	0xa3, 0x33, 0x5d, 0x21, 0x50, 0xd5, 0xb2, 0x20, 0xca, 0x1e, 0xd5, 0x36, 0x55, 0x1e, 0x77, 0xd6,
	0xf3, 0x94, 0x95, 0x1a, 0xae, 0xb0, 0x0c, 0x8a, 0x5a, 0x35, 0xb8, 0x72, 0x36, 0x1d, 0x87, 0x85,
	0x94, 0x8d, 0x1a, 0xbf, 0x9a, 0x50, 0x5d, 0x76, 0xe9, 0x98, 0x53, 0x17, 0x75, 0x61, 0x2b, 0x59,
	0x1d, 0xd5, 0x4c, 0x15, 0xc8, 0xcd, 0x8b, 0x04, 0x82, 0x53, 0x12, 0xd4, 0x81, 0x0d, 0x1e, 0x8b,
	0x4c, 0x4b, 0xe8, 0xc6, 0x7a, 0x6c, 0x4a, 0x9f, 0x38, 0x61, 0x68, 0x5c, 0x87, 0xed, 0x56, 0xff,
	0x9e, 0x8a, 0x17, 0xd5, 0x60, 0x8b, 0x0b, 0x36, 0x16, 0x64, 0xa2, 0x55, 0x9b, 0xc2, 0xc6, 0x3e,
	0x14, 0xbe, 0xe9, 0x77, 0x0e, 0x62, 0x51, 0x93, 0x48, 0x0b, 0xbe, 0x82, 0xd5, 0x18, 0xed, 0x40,
	0x9e, 0xfb, 0x9e, 0x0a, 0xa5, 0x82, 0xe3, 0x21, 0xfa, 0x3f, 0x6c, 0xc8, 0xc8, 0x09, 0x63, 0x35,
	0x9a, 0xbb, 0x05, 0x5c, 0x90, 0x51, 0x37, 0x6a, 0xfc, 0xbc, 0x05, 0xd5, 0x03, 0xca, 0x03, 0x36,
	0x8b, 0xa5, 0xa6, 0xca, 0xd2, 0x86, 0xc2, 0x94, 0x6b, 0xb6, 0xd2, 0xde, 0xde, 0x7a, 0x59, 0xc4,
	0xf1, 0xb4, 0x0d, 0xac, 0x18, 0x10, 0x87, 0x4a, 0xf4, 0x88, 0x08, 0xea, 0x39, 0x6c, 0x78, 0x4a,
	0xdd, 0x74, 0x6f, 0x75, 0xd6, 0xa3, 0x5c, 0x0d, 0xcf, 0x3e, 0x56, 0x8c, 0x3d, 0x45, 0xd8, 0x36,
	0x70, 0x39, 0xca, 0x60, 0x74, 0x0a, 0x25, 0xce, 0x3c, 0x87, 0x0b, 0xe6, 0xd2, 0x28, 0xc9, 0xb4,
	0xb4, 0xf7, 0xd5, 0x5b, 0xf9, 0xeb, 0x33, 0xaf, 0x9f, 0xd0, 0xb5, 0x0d, 0x0c, 0x7c, 0x81, 0x50,
	0x04, 0xd5, 0x80, 0x0c, 0x69, 0xe0, 0x44, 0x34, 0xa0, 0xae, 0x64, 0xa2, 0x56, 0x50, 0xee, 0xee,
	0xbf, 0x95, 0xbb, 0xa3, 0x98, 0xf2, 0x58, 0x33, 0xb6, 0x0d, 0x5c, 0x09, 0xb2, 0x86, 0xfa, 0x29,
	0x94, 0xb3, 0x05, 0x38, 0xf7, 0x3c, 0xbb, 0xa7, 0x1b, 0x98, 0xbb, 0x68, 0x03, 0x93, 0xf6, 0xd5,
	0x1f, 0x02, 0x2c, 0x93, 0x8f, 0x3d, 0x71, 0xe6, 0x25, 0x5b, 0xa5, 0x88, 0xd5, 0x18, 0xbd, 0x0b,
	0x45, 0x97, 0x85, 0x92, 0xf8, 0x21, 0x4d, 0xef, 0x91, 0xa5, 0x41, 0x0b, 0x77, 0xd1, 0x88, 0x44,
	0xb8, 0x31, 0xac, 0x3f, 0xcb, 0x41, 0x65, 0x25, 0x51, 0x14, 0xc2, 0xa6, 0x4a, 0x34, 0xdd, 0x8a,
	0x27, 0xff, 0x5d, 0x11, 0x13, 0x14, 0x1d, 0x86, 0x52, 0xcc, 0xb0, 0xf6, 0x12, 0x47, 0xae, 0x2e,
	0x1e, 0x4e, 0x5c, 0x9a, 0x46, 0xbe, 0x30, 0xac, 0xe6, 0x95, 0xff, 0x87, 0xbc, 0x0a, 0xab, 0x79,
	0xdd, 0x86, 0x52, 0xc6, 0x59, 0xbc, 0x07, 0x7f, 0xa0, 0x33, 0xdd, 0x9b, 0x78, 0x88, 0x2e, 0xc3,
	0xc6, 0xe3, 0xf8, 0x00, 0xd6, 0x2e, 0x13, 0x70, 0x27, 0x77, 0xcb, 0x6c, 0x55, 0xa1, 0x2c, 0x89,
	0x18, 0x53, 0xa9, 0xcf, 0xab, 0x9f, 0x4c, 0x40, 0x99, 0xf3, 0x2a, 0xad, 0x93, 0x03, 0x95, 0x54,
	0x6e, 0x8e, 0x9c, 0xf1, 0xa4, 0xf1, 0xd5, 0x75, 0x8f, 0xd0, 0x94, 0x6e, 0x30, 0xe3, 0x14, 0x97,
	0xa3, 0x0c, 0x3a, 0x3f, 0xc2, 0xc6, 0x8f, 0x1b, 0x70, 0x79, 0x19, 0xcd, 0xb2, 0xda, 0xe7, 0xea,
	0xef, 0x26, 0xe4, 0xa5, 0x0c, 0xb4, 0xfc, 0xde, 0xb1, 0x93, 0x57, 0x8d, 0x9d, 0xbe, 0x6a, 0xec,
	0x03, 0xfd, 0xaa, 0x69, 0x6d, 0xcd, 0x5f, 0x5e, 0xcd, 0x0f, 0x06, 0x47, 0x38, 0x9e, 0x8e, 0x28,
	0x5c, 0xf2, 0x16, 0xbc, 0x4e, 0xc4, 0xa9, 0xab, 0xb7, 0xef, 0x67, 0x6f, 0x23, 0x05, 0x5c, 0xf5,
	0x56, 0x4f, 0x37, 0x0e, 0xdb, 0xfa, 0xf8, 0x4c, 0xaf, 0xd1, 0xc1, 0x45, 0xaf, 0xfa, 0xa5, 0xa7,
	0x8c, 0xb1, 0x9f, 0x90, 0xe3, 0x85, 0x97, 0xfa, 0x6f, 0x39, 0xf8, 0xdf, 0xdf, 0xbe, 0xa3, 0xf7,
	0x00, 0xe4, 0xe2, 0xfd, 0xa3, 0xcb, 0x57, 0x94, 0xe9, 0xdb, 0x07, 0xf5, 0xa1, 0xa0, 0x4a, 0x90,
	0xbb, 0x48, 0x09, 0x56, 0xef, 0x39, 0xac, 0x98, 0xd0, 0xf7, 0xb0, 0x3d, 0xe4, 0x23, 0xf5, 0x38,
	0xd1, 0x85, 0x5d, 0xf3, 0x3d, 0x92, 0x5e, 0x48, 0xad, 0xf2, 0xfc, 0xe5, 0xd5, 0xc5, 0xf5, 0x84,
	0x17, 0xac, 0xe8, 0x3b, 0x28, 0xa6, 0x52, 0x4a, 0x6b, 0xfb, 0xc5, 0x85, 0x03, 0xd7, 0x44, 0x78,
	0x49, 0xf9, 0x61, 0x0f, 0xca, 0x59, 0xe1, 0xa2, 0x1d, 0x28, 0x77, 0x7b, 0xce, 0x97, 0xbd, 0xee,
	0x41, 0x67, 0xd0, 0xe9, 0x75, 0x77, 0x0c, 0x54, 0x05, 0x78, 0xb0, 0xff, 0xd0, 0xf9, 0xfa, 0x10,
	0x77, 0x0f, 0x8f, 0x76, 0x4c, 0x85, 0x3b, 0xdd, 0x14, 0xe7, 0x50, 0x05, 0x8a, 0xed, 0xde, 0xf1,
	0xc0, 0xe9, 0xee, 0x3f, 0x38, 0xdc, 0xc9, 0xb7, 0x3e, 0x7f, 0xfe, 0xca, 0x32, 0x5e, 0xbc, 0xb2,
	0x8c, 0x37, 0xaf, 0x2c, 0xf3, 0xe9, 0xdc, 0x32, 0x7f, 0x99, 0x5b, 0xe6, 0xef, 0x73, 0xcb, 0x7c,
	0x3e, 0xb7, 0xcc, 0x3f, 0xe6, 0x96, 0xf9, 0xe7, 0xdc, 0x32, 0xde, 0xcc, 0x2d, 0xf3, 0xd9, 0x6b,
	0xcb, 0x78, 0xfe, 0xda, 0x32, 0x5e, 0xbc, 0xb6, 0x8c, 0x6f, 0x8b, 0x8b, 0x9f, 0x83, 0xe1, 0xa6,
	0x12, 0xf5, 0x8d, 0xbf, 0x02, 0x00, 0x00, 0xff, 0xff, 0x57, 0x7f, 0xe3, 0x0f, 0x56, 0x0c, 0x00,
	0x00,
}

func (x SelectorType) String() string {
	s, ok := SelectorType_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (this *Argument) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Argument)
	if !ok {
		that2, ok := that.(Argument)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Id != that1.Id {
		return false
	}
	if this.Expr != that1.Expr {
		return false
	}
	return true
}
func (this *ReturnValue) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ReturnValue)
	if !ok {
		that2, ok := that.(ReturnValue)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Id != that1.Id {
		return false
	}
	if this.Expr != that1.Expr {
		return false
	}
	return true
}
func (this *Output) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Output)
	if !ok {
		that2, ok := that.(Output)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if len(this.Fields) != len(that1.Fields) {
		return false
	}
	for i := range this.Fields {
		if this.Fields[i] != that1.Fields[i] {
			return false
		}
	}
	return true
}
func (this *OutputAction) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*OutputAction)
	if !ok {
		that2, ok := that.(OutputAction)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.OutputName != that1.OutputName {
		return false
	}
	if len(this.VariableNames) != len(that1.VariableNames) {
		return false
	}
	for i := range this.VariableNames {
		if this.VariableNames[i] != that1.VariableNames[i] {
			return false
		}
	}
	return true
}
func (this *Tracepoint) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Tracepoint)
	if !ok {
		that2, ok := that.(Tracepoint)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Symbol != that1.Symbol {
		return false
	}
	return true
}
func (this *FunctionLatency) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*FunctionLatency)
	if !ok {
		that2, ok := that.(FunctionLatency)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Id != that1.Id {
		return false
	}
	return true
}
func (this *Probe) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Probe)
	if !ok {
		that2, ok := that.(Probe)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if !this.Tracepoint.Equal(that1.Tracepoint) {
		return false
	}
	if len(this.Args) != len(that1.Args) {
		return false
	}
	for i := range this.Args {
		if !this.Args[i].Equal(that1.Args[i]) {
			return false
		}
	}
	if len(this.RetVals) != len(that1.RetVals) {
		return false
	}
	for i := range this.RetVals {
		if !this.RetVals[i].Equal(that1.RetVals[i]) {
			return false
		}
	}
	if that1.FunctionLatencyOneof == nil {
		if this.FunctionLatencyOneof != nil {
			return false
		}
	} else if this.FunctionLatencyOneof == nil {
		return false
	} else if !this.FunctionLatencyOneof.Equal(that1.FunctionLatencyOneof) {
		return false
	}
	if len(this.OutputActions) != len(that1.OutputActions) {
		return false
	}
	for i := range this.OutputActions {
		if !this.OutputActions[i].Equal(that1.OutputActions[i]) {
			return false
		}
	}
	return true
}
func (this *Probe_FunctionLatency) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Probe_FunctionLatency)
	if !ok {
		that2, ok := that.(Probe_FunctionLatency)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.FunctionLatency.Equal(that1.FunctionLatency) {
		return false
	}
	return true
}
func (this *TracepointSpec) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*TracepointSpec)
	if !ok {
		that2, ok := that.(TracepointSpec)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Outputs) != len(that1.Outputs) {
		return false
	}
	for i := range this.Outputs {
		if !this.Outputs[i].Equal(that1.Outputs[i]) {
			return false
		}
	}
	if !this.Probe.Equal(that1.Probe) {
		return false
	}
	return true
}
func (this *BPFTrace) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*BPFTrace)
	if !ok {
		that2, ok := that.(BPFTrace)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Program != that1.Program {
		return false
	}
	return true
}
func (this *UPID) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*UPID)
	if !ok {
		that2, ok := that.(UPID)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Asid != that1.Asid {
		return false
	}
	if this.Pid != that1.Pid {
		return false
	}
	if this.TsNs != that1.TsNs {
		return false
	}
	return true
}
func (this *DeploymentSpec) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DeploymentSpec)
	if !ok {
		that2, ok := that.(DeploymentSpec)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if that1.TargetOneof == nil {
		if this.TargetOneof != nil {
			return false
		}
	} else if this.TargetOneof == nil {
		return false
	} else if !this.TargetOneof.Equal(that1.TargetOneof) {
		return false
	}
	return true
}
func (this *DeploymentSpec_Upid) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DeploymentSpec_Upid)
	if !ok {
		that2, ok := that.(DeploymentSpec_Upid)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Upid.Equal(that1.Upid) {
		return false
	}
	return true
}
func (this *DeploymentSpec_SharedObject_) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DeploymentSpec_SharedObject_)
	if !ok {
		that2, ok := that.(DeploymentSpec_SharedObject_)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.SharedObject.Equal(that1.SharedObject) {
		return false
	}
	return true
}
func (this *DeploymentSpec_PodProcess_) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DeploymentSpec_PodProcess_)
	if !ok {
		that2, ok := that.(DeploymentSpec_PodProcess_)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.PodProcess.Equal(that1.PodProcess) {
		return false
	}
	return true
}
func (this *DeploymentSpec_LabelSelector_) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DeploymentSpec_LabelSelector_)
	if !ok {
		that2, ok := that.(DeploymentSpec_LabelSelector_)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.LabelSelector.Equal(that1.LabelSelector) {
		return false
	}
	return true
}
func (this *DeploymentSpec_SharedObject) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DeploymentSpec_SharedObject)
	if !ok {
		that2, ok := that.(DeploymentSpec_SharedObject)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if !this.Upid.Equal(that1.Upid) {
		return false
	}
	return true
}
func (this *DeploymentSpec_PodProcess) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DeploymentSpec_PodProcess)
	if !ok {
		that2, ok := that.(DeploymentSpec_PodProcess)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Pods) != len(that1.Pods) {
		return false
	}
	for i := range this.Pods {
		if this.Pods[i] != that1.Pods[i] {
			return false
		}
	}
	if this.Container != that1.Container {
		return false
	}
	if this.Process != that1.Process {
		return false
	}
	return true
}
func (this *DeploymentSpec_LabelSelector) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DeploymentSpec_LabelSelector)
	if !ok {
		that2, ok := that.(DeploymentSpec_LabelSelector)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Labels) != len(that1.Labels) {
		return false
	}
	for i := range this.Labels {
		if this.Labels[i] != that1.Labels[i] {
			return false
		}
	}
	if this.Namespace != that1.Namespace {
		return false
	}
	if this.Container != that1.Container {
		return false
	}
	if this.Process != that1.Process {
		return false
	}
	return true
}
func (this *TracepointSelector) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*TracepointSelector)
	if !ok {
		that2, ok := that.(TracepointSelector)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.SelectorType != that1.SelectorType {
		return false
	}
	if this.Value != that1.Value {
		return false
	}
	return true
}
func (this *TracepointDeployment) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*TracepointDeployment)
	if !ok {
		that2, ok := that.(TracepointDeployment)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if !this.TTL.Equal(that1.TTL) {
		return false
	}
	if !this.DeploymentSpec.Equal(that1.DeploymentSpec) {
		return false
	}
	if len(this.Programs) != len(that1.Programs) {
		return false
	}
	for i := range this.Programs {
		if !this.Programs[i].Equal(that1.Programs[i]) {
			return false
		}
	}
	return true
}
func (this *TracepointDeployment_TracepointProgram) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*TracepointDeployment_TracepointProgram)
	if !ok {
		that2, ok := that.(TracepointDeployment_TracepointProgram)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.TableName != that1.TableName {
		return false
	}
	if !this.Spec.Equal(that1.Spec) {
		return false
	}
	if !this.BPFTrace.Equal(that1.BPFTrace) {
		return false
	}
	if len(this.Selectors) != len(that1.Selectors) {
		return false
	}
	for i := range this.Selectors {
		if !this.Selectors[i].Equal(that1.Selectors[i]) {
			return false
		}
	}
	return true
}
func (this *Argument) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&logicalpb.Argument{")
	s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n")
	s = append(s, "Expr: "+fmt.Sprintf("%#v", this.Expr)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ReturnValue) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&logicalpb.ReturnValue{")
	s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n")
	s = append(s, "Expr: "+fmt.Sprintf("%#v", this.Expr)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Output) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&logicalpb.Output{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "Fields: "+fmt.Sprintf("%#v", this.Fields)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *OutputAction) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&logicalpb.OutputAction{")
	s = append(s, "OutputName: "+fmt.Sprintf("%#v", this.OutputName)+",\n")
	s = append(s, "VariableNames: "+fmt.Sprintf("%#v", this.VariableNames)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Tracepoint) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&logicalpb.Tracepoint{")
	s = append(s, "Symbol: "+fmt.Sprintf("%#v", this.Symbol)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *FunctionLatency) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&logicalpb.FunctionLatency{")
	s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Probe) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 10)
	s = append(s, "&logicalpb.Probe{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	if this.Tracepoint != nil {
		s = append(s, "Tracepoint: "+fmt.Sprintf("%#v", this.Tracepoint)+",\n")
	}
	if this.Args != nil {
		s = append(s, "Args: "+fmt.Sprintf("%#v", this.Args)+",\n")
	}
	if this.RetVals != nil {
		s = append(s, "RetVals: "+fmt.Sprintf("%#v", this.RetVals)+",\n")
	}
	if this.FunctionLatencyOneof != nil {
		s = append(s, "FunctionLatencyOneof: "+fmt.Sprintf("%#v", this.FunctionLatencyOneof)+",\n")
	}
	if this.OutputActions != nil {
		s = append(s, "OutputActions: "+fmt.Sprintf("%#v", this.OutputActions)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Probe_FunctionLatency) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&logicalpb.Probe_FunctionLatency{` +
		`FunctionLatency:` + fmt.Sprintf("%#v", this.FunctionLatency) + `}`}, ", ")
	return s
}
func (this *TracepointSpec) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&logicalpb.TracepointSpec{")
	if this.Outputs != nil {
		s = append(s, "Outputs: "+fmt.Sprintf("%#v", this.Outputs)+",\n")
	}
	if this.Probe != nil {
		s = append(s, "Probe: "+fmt.Sprintf("%#v", this.Probe)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *BPFTrace) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&logicalpb.BPFTrace{")
	s = append(s, "Program: "+fmt.Sprintf("%#v", this.Program)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *UPID) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&logicalpb.UPID{")
	s = append(s, "Asid: "+fmt.Sprintf("%#v", this.Asid)+",\n")
	s = append(s, "Pid: "+fmt.Sprintf("%#v", this.Pid)+",\n")
	s = append(s, "TsNs: "+fmt.Sprintf("%#v", this.TsNs)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DeploymentSpec) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&logicalpb.DeploymentSpec{")
	if this.TargetOneof != nil {
		s = append(s, "TargetOneof: "+fmt.Sprintf("%#v", this.TargetOneof)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DeploymentSpec_Upid) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&logicalpb.DeploymentSpec_Upid{` +
		`Upid:` + fmt.Sprintf("%#v", this.Upid) + `}`}, ", ")
	return s
}
func (this *DeploymentSpec_SharedObject_) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&logicalpb.DeploymentSpec_SharedObject_{` +
		`SharedObject:` + fmt.Sprintf("%#v", this.SharedObject) + `}`}, ", ")
	return s
}
func (this *DeploymentSpec_PodProcess_) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&logicalpb.DeploymentSpec_PodProcess_{` +
		`PodProcess:` + fmt.Sprintf("%#v", this.PodProcess) + `}`}, ", ")
	return s
}
func (this *DeploymentSpec_LabelSelector_) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&logicalpb.DeploymentSpec_LabelSelector_{` +
		`LabelSelector:` + fmt.Sprintf("%#v", this.LabelSelector) + `}`}, ", ")
	return s
}
func (this *DeploymentSpec_SharedObject) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&logicalpb.DeploymentSpec_SharedObject{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	if this.Upid != nil {
		s = append(s, "Upid: "+fmt.Sprintf("%#v", this.Upid)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DeploymentSpec_PodProcess) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&logicalpb.DeploymentSpec_PodProcess{")
	s = append(s, "Pods: "+fmt.Sprintf("%#v", this.Pods)+",\n")
	s = append(s, "Container: "+fmt.Sprintf("%#v", this.Container)+",\n")
	s = append(s, "Process: "+fmt.Sprintf("%#v", this.Process)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DeploymentSpec_LabelSelector) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&logicalpb.DeploymentSpec_LabelSelector{")
	keysForLabels := make([]string, 0, len(this.Labels))
	for k, _ := range this.Labels {
		keysForLabels = append(keysForLabels, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForLabels)
	mapStringForLabels := "map[string]string{"
	for _, k := range keysForLabels {
		mapStringForLabels += fmt.Sprintf("%#v: %#v,", k, this.Labels[k])
	}
	mapStringForLabels += "}"
	if this.Labels != nil {
		s = append(s, "Labels: "+mapStringForLabels+",\n")
	}
	s = append(s, "Namespace: "+fmt.Sprintf("%#v", this.Namespace)+",\n")
	s = append(s, "Container: "+fmt.Sprintf("%#v", this.Container)+",\n")
	s = append(s, "Process: "+fmt.Sprintf("%#v", this.Process)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *TracepointSelector) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&logicalpb.TracepointSelector{")
	s = append(s, "SelectorType: "+fmt.Sprintf("%#v", this.SelectorType)+",\n")
	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *TracepointDeployment) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&logicalpb.TracepointDeployment{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	if this.TTL != nil {
		s = append(s, "TTL: "+fmt.Sprintf("%#v", this.TTL)+",\n")
	}
	if this.DeploymentSpec != nil {
		s = append(s, "DeploymentSpec: "+fmt.Sprintf("%#v", this.DeploymentSpec)+",\n")
	}
	if this.Programs != nil {
		s = append(s, "Programs: "+fmt.Sprintf("%#v", this.Programs)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *TracepointDeployment_TracepointProgram) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&logicalpb.TracepointDeployment_TracepointProgram{")
	s = append(s, "TableName: "+fmt.Sprintf("%#v", this.TableName)+",\n")
	if this.Spec != nil {
		s = append(s, "Spec: "+fmt.Sprintf("%#v", this.Spec)+",\n")
	}
	if this.BPFTrace != nil {
		s = append(s, "BPFTrace: "+fmt.Sprintf("%#v", this.BPFTrace)+",\n")
	}
	if this.Selectors != nil {
		s = append(s, "Selectors: "+fmt.Sprintf("%#v", this.Selectors)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringLogical(v interface{}, typ string) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}
func (m *Argument) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Argument) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Argument) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Expr) > 0 {
		i -= len(m.Expr)
		copy(dAtA[i:], m.Expr)
		i = encodeVarintLogical(dAtA, i, uint64(len(m.Expr)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintLogical(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ReturnValue) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ReturnValue) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ReturnValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Expr) > 0 {
		i -= len(m.Expr)
		copy(dAtA[i:], m.Expr)
		i = encodeVarintLogical(dAtA, i, uint64(len(m.Expr)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintLogical(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Output) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Output) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Output) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Fields) > 0 {
		for iNdEx := len(m.Fields) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Fields[iNdEx])
			copy(dAtA[i:], m.Fields[iNdEx])
			i = encodeVarintLogical(dAtA, i, uint64(len(m.Fields[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintLogical(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *OutputAction) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *OutputAction) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *OutputAction) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.VariableNames) > 0 {
		for iNdEx := len(m.VariableNames) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.VariableNames[iNdEx])
			copy(dAtA[i:], m.VariableNames[iNdEx])
			i = encodeVarintLogical(dAtA, i, uint64(len(m.VariableNames[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.OutputName) > 0 {
		i -= len(m.OutputName)
		copy(dAtA[i:], m.OutputName)
		i = encodeVarintLogical(dAtA, i, uint64(len(m.OutputName)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Tracepoint) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Tracepoint) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Tracepoint) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Symbol) > 0 {
		i -= len(m.Symbol)
		copy(dAtA[i:], m.Symbol)
		i = encodeVarintLogical(dAtA, i, uint64(len(m.Symbol)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *FunctionLatency) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *FunctionLatency) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FunctionLatency) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintLogical(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Probe) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Probe) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Probe) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.OutputActions) > 0 {
		for iNdEx := len(m.OutputActions) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.OutputActions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintLogical(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	if m.FunctionLatencyOneof != nil {
		{
			size := m.FunctionLatencyOneof.Size()
			i -= size
			if _, err := m.FunctionLatencyOneof.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if len(m.RetVals) > 0 {
		for iNdEx := len(m.RetVals) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.RetVals[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintLogical(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Args) > 0 {
		for iNdEx := len(m.Args) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Args[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintLogical(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Tracepoint != nil {
		{
			size, err := m.Tracepoint.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLogical(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintLogical(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Probe_FunctionLatency) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Probe_FunctionLatency) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.FunctionLatency != nil {
		{
			size, err := m.FunctionLatency.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLogical(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	return len(dAtA) - i, nil
}
func (m *TracepointSpec) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TracepointSpec) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TracepointSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Probe != nil {
		{
			size, err := m.Probe.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLogical(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Outputs) > 0 {
		for iNdEx := len(m.Outputs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Outputs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintLogical(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *BPFTrace) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *BPFTrace) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BPFTrace) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Program) > 0 {
		i -= len(m.Program)
		copy(dAtA[i:], m.Program)
		i = encodeVarintLogical(dAtA, i, uint64(len(m.Program)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *UPID) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *UPID) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UPID) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TsNs != 0 {
		i = encodeVarintLogical(dAtA, i, uint64(m.TsNs))
		i--
		dAtA[i] = 0x18
	}
	if m.Pid != 0 {
		i = encodeVarintLogical(dAtA, i, uint64(m.Pid))
		i--
		dAtA[i] = 0x10
	}
	if m.Asid != 0 {
		i = encodeVarintLogical(dAtA, i, uint64(m.Asid))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *DeploymentSpec) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DeploymentSpec) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DeploymentSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TargetOneof != nil {
		{
			size := m.TargetOneof.Size()
			i -= size
			if _, err := m.TargetOneof.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

func (m *DeploymentSpec_Upid) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DeploymentSpec_Upid) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Upid != nil {
		{
			size, err := m.Upid.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLogical(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *DeploymentSpec_SharedObject_) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DeploymentSpec_SharedObject_) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.SharedObject != nil {
		{
			size, err := m.SharedObject.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLogical(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *DeploymentSpec_PodProcess_) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DeploymentSpec_PodProcess_) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.PodProcess != nil {
		{
			size, err := m.PodProcess.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLogical(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *DeploymentSpec_LabelSelector_) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DeploymentSpec_LabelSelector_) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.LabelSelector != nil {
		{
			size, err := m.LabelSelector.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLogical(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	return len(dAtA) - i, nil
}
func (m *DeploymentSpec_SharedObject) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DeploymentSpec_SharedObject) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DeploymentSpec_SharedObject) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Upid != nil {
		{
			size, err := m.Upid.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLogical(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintLogical(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DeploymentSpec_PodProcess) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DeploymentSpec_PodProcess) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DeploymentSpec_PodProcess) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Process) > 0 {
		i -= len(m.Process)
		copy(dAtA[i:], m.Process)
		i = encodeVarintLogical(dAtA, i, uint64(len(m.Process)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Container) > 0 {
		i -= len(m.Container)
		copy(dAtA[i:], m.Container)
		i = encodeVarintLogical(dAtA, i, uint64(len(m.Container)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Pods) > 0 {
		for iNdEx := len(m.Pods) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Pods[iNdEx])
			copy(dAtA[i:], m.Pods[iNdEx])
			i = encodeVarintLogical(dAtA, i, uint64(len(m.Pods[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *DeploymentSpec_LabelSelector) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DeploymentSpec_LabelSelector) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DeploymentSpec_LabelSelector) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Process) > 0 {
		i -= len(m.Process)
		copy(dAtA[i:], m.Process)
		i = encodeVarintLogical(dAtA, i, uint64(len(m.Process)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Container) > 0 {
		i -= len(m.Container)
		copy(dAtA[i:], m.Container)
		i = encodeVarintLogical(dAtA, i, uint64(len(m.Container)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintLogical(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Labels) > 0 {
		for k := range m.Labels {
			v := m.Labels[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintLogical(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintLogical(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintLogical(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *TracepointSelector) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TracepointSelector) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TracepointSelector) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Value) > 0 {
		i -= len(m.Value)
		copy(dAtA[i:], m.Value)
		i = encodeVarintLogical(dAtA, i, uint64(len(m.Value)))
		i--
		dAtA[i] = 0x12
	}
	if m.SelectorType != 0 {
		i = encodeVarintLogical(dAtA, i, uint64(m.SelectorType))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *TracepointDeployment) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TracepointDeployment) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TracepointDeployment) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Programs) > 0 {
		for iNdEx := len(m.Programs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Programs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintLogical(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if m.DeploymentSpec != nil {
		{
			size, err := m.DeploymentSpec.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLogical(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.TTL != nil {
		{
			size, err := m.TTL.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLogical(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintLogical(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *TracepointDeployment_TracepointProgram) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TracepointDeployment_TracepointProgram) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TracepointDeployment_TracepointProgram) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Selectors) > 0 {
		for iNdEx := len(m.Selectors) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Selectors[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintLogical(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if m.BPFTrace != nil {
		{
			size, err := m.BPFTrace.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLogical(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Spec != nil {
		{
			size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLogical(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.TableName) > 0 {
		i -= len(m.TableName)
		copy(dAtA[i:], m.TableName)
		i = encodeVarintLogical(dAtA, i, uint64(len(m.TableName)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintLogical(dAtA []byte, offset int, v uint64) int {
	offset -= sovLogical(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *Argument) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovLogical(uint64(l))
	}
	l = len(m.Expr)
	if l > 0 {
		n += 1 + l + sovLogical(uint64(l))
	}
	return n
}

func (m *ReturnValue) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovLogical(uint64(l))
	}
	l = len(m.Expr)
	if l > 0 {
		n += 1 + l + sovLogical(uint64(l))
	}
	return n
}

func (m *Output) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovLogical(uint64(l))
	}
	if len(m.Fields) > 0 {
		for _, s := range m.Fields {
			l = len(s)
			n += 1 + l + sovLogical(uint64(l))
		}
	}
	return n
}

func (m *OutputAction) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.OutputName)
	if l > 0 {
		n += 1 + l + sovLogical(uint64(l))
	}
	if len(m.VariableNames) > 0 {
		for _, s := range m.VariableNames {
			l = len(s)
			n += 1 + l + sovLogical(uint64(l))
		}
	}
	return n
}

func (m *Tracepoint) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Symbol)
	if l > 0 {
		n += 1 + l + sovLogical(uint64(l))
	}
	return n
}

func (m *FunctionLatency) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovLogical(uint64(l))
	}
	return n
}

func (m *Probe) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovLogical(uint64(l))
	}
	if m.Tracepoint != nil {
		l = m.Tracepoint.Size()
		n += 1 + l + sovLogical(uint64(l))
	}
	if len(m.Args) > 0 {
		for _, e := range m.Args {
			l = e.Size()
			n += 1 + l + sovLogical(uint64(l))
		}
	}
	if len(m.RetVals) > 0 {
		for _, e := range m.RetVals {
			l = e.Size()
			n += 1 + l + sovLogical(uint64(l))
		}
	}
	if m.FunctionLatencyOneof != nil {
		n += m.FunctionLatencyOneof.Size()
	}
	if len(m.OutputActions) > 0 {
		for _, e := range m.OutputActions {
			l = e.Size()
			n += 1 + l + sovLogical(uint64(l))
		}
	}
	return n
}

func (m *Probe_FunctionLatency) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.FunctionLatency != nil {
		l = m.FunctionLatency.Size()
		n += 1 + l + sovLogical(uint64(l))
	}
	return n
}
func (m *TracepointSpec) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Outputs) > 0 {
		for _, e := range m.Outputs {
			l = e.Size()
			n += 1 + l + sovLogical(uint64(l))
		}
	}
	if m.Probe != nil {
		l = m.Probe.Size()
		n += 1 + l + sovLogical(uint64(l))
	}
	return n
}

func (m *BPFTrace) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Program)
	if l > 0 {
		n += 1 + l + sovLogical(uint64(l))
	}
	return n
}

func (m *UPID) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Asid != 0 {
		n += 1 + sovLogical(uint64(m.Asid))
	}
	if m.Pid != 0 {
		n += 1 + sovLogical(uint64(m.Pid))
	}
	if m.TsNs != 0 {
		n += 1 + sovLogical(uint64(m.TsNs))
	}
	return n
}

func (m *DeploymentSpec) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TargetOneof != nil {
		n += m.TargetOneof.Size()
	}
	return n
}

func (m *DeploymentSpec_Upid) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Upid != nil {
		l = m.Upid.Size()
		n += 1 + l + sovLogical(uint64(l))
	}
	return n
}
func (m *DeploymentSpec_SharedObject_) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SharedObject != nil {
		l = m.SharedObject.Size()
		n += 1 + l + sovLogical(uint64(l))
	}
	return n
}
func (m *DeploymentSpec_PodProcess_) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PodProcess != nil {
		l = m.PodProcess.Size()
		n += 1 + l + sovLogical(uint64(l))
	}
	return n
}
func (m *DeploymentSpec_LabelSelector_) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.LabelSelector != nil {
		l = m.LabelSelector.Size()
		n += 1 + l + sovLogical(uint64(l))
	}
	return n
}
func (m *DeploymentSpec_SharedObject) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovLogical(uint64(l))
	}
	if m.Upid != nil {
		l = m.Upid.Size()
		n += 1 + l + sovLogical(uint64(l))
	}
	return n
}

func (m *DeploymentSpec_PodProcess) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Pods) > 0 {
		for _, s := range m.Pods {
			l = len(s)
			n += 1 + l + sovLogical(uint64(l))
		}
	}
	l = len(m.Container)
	if l > 0 {
		n += 1 + l + sovLogical(uint64(l))
	}
	l = len(m.Process)
	if l > 0 {
		n += 1 + l + sovLogical(uint64(l))
	}
	return n
}

func (m *DeploymentSpec_LabelSelector) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Labels) > 0 {
		for k, v := range m.Labels {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovLogical(uint64(len(k))) + 1 + len(v) + sovLogical(uint64(len(v)))
			n += mapEntrySize + 1 + sovLogical(uint64(mapEntrySize))
		}
	}
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovLogical(uint64(l))
	}
	l = len(m.Container)
	if l > 0 {
		n += 1 + l + sovLogical(uint64(l))
	}
	l = len(m.Process)
	if l > 0 {
		n += 1 + l + sovLogical(uint64(l))
	}
	return n
}

func (m *TracepointSelector) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SelectorType != 0 {
		n += 1 + sovLogical(uint64(m.SelectorType))
	}
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovLogical(uint64(l))
	}
	return n
}

func (m *TracepointDeployment) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovLogical(uint64(l))
	}
	if m.TTL != nil {
		l = m.TTL.Size()
		n += 1 + l + sovLogical(uint64(l))
	}
	if m.DeploymentSpec != nil {
		l = m.DeploymentSpec.Size()
		n += 1 + l + sovLogical(uint64(l))
	}
	if len(m.Programs) > 0 {
		for _, e := range m.Programs {
			l = e.Size()
			n += 1 + l + sovLogical(uint64(l))
		}
	}
	return n
}

func (m *TracepointDeployment_TracepointProgram) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.TableName)
	if l > 0 {
		n += 1 + l + sovLogical(uint64(l))
	}
	if m.Spec != nil {
		l = m.Spec.Size()
		n += 1 + l + sovLogical(uint64(l))
	}
	if m.BPFTrace != nil {
		l = m.BPFTrace.Size()
		n += 1 + l + sovLogical(uint64(l))
	}
	if len(m.Selectors) > 0 {
		for _, e := range m.Selectors {
			l = e.Size()
			n += 1 + l + sovLogical(uint64(l))
		}
	}
	return n
}

func sovLogical(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozLogical(x uint64) (n int) {
	return sovLogical(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *Argument) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Argument{`,
		`Id:` + fmt.Sprintf("%v", this.Id) + `,`,
		`Expr:` + fmt.Sprintf("%v", this.Expr) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ReturnValue) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ReturnValue{`,
		`Id:` + fmt.Sprintf("%v", this.Id) + `,`,
		`Expr:` + fmt.Sprintf("%v", this.Expr) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Output) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Output{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Fields:` + fmt.Sprintf("%v", this.Fields) + `,`,
		`}`,
	}, "")
	return s
}
func (this *OutputAction) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&OutputAction{`,
		`OutputName:` + fmt.Sprintf("%v", this.OutputName) + `,`,
		`VariableNames:` + fmt.Sprintf("%v", this.VariableNames) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Tracepoint) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Tracepoint{`,
		`Symbol:` + fmt.Sprintf("%v", this.Symbol) + `,`,
		`}`,
	}, "")
	return s
}
func (this *FunctionLatency) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&FunctionLatency{`,
		`Id:` + fmt.Sprintf("%v", this.Id) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Probe) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForArgs := "[]*Argument{"
	for _, f := range this.Args {
		repeatedStringForArgs += strings.Replace(f.String(), "Argument", "Argument", 1) + ","
	}
	repeatedStringForArgs += "}"
	repeatedStringForRetVals := "[]*ReturnValue{"
	for _, f := range this.RetVals {
		repeatedStringForRetVals += strings.Replace(f.String(), "ReturnValue", "ReturnValue", 1) + ","
	}
	repeatedStringForRetVals += "}"
	repeatedStringForOutputActions := "[]*OutputAction{"
	for _, f := range this.OutputActions {
		repeatedStringForOutputActions += strings.Replace(f.String(), "OutputAction", "OutputAction", 1) + ","
	}
	repeatedStringForOutputActions += "}"
	s := strings.Join([]string{`&Probe{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Tracepoint:` + strings.Replace(this.Tracepoint.String(), "Tracepoint", "Tracepoint", 1) + `,`,
		`Args:` + repeatedStringForArgs + `,`,
		`RetVals:` + repeatedStringForRetVals + `,`,
		`FunctionLatencyOneof:` + fmt.Sprintf("%v", this.FunctionLatencyOneof) + `,`,
		`OutputActions:` + repeatedStringForOutputActions + `,`,
		`}`,
	}, "")
	return s
}
func (this *Probe_FunctionLatency) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Probe_FunctionLatency{`,
		`FunctionLatency:` + strings.Replace(fmt.Sprintf("%v", this.FunctionLatency), "FunctionLatency", "FunctionLatency", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *TracepointSpec) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForOutputs := "[]*Output{"
	for _, f := range this.Outputs {
		repeatedStringForOutputs += strings.Replace(f.String(), "Output", "Output", 1) + ","
	}
	repeatedStringForOutputs += "}"
	s := strings.Join([]string{`&TracepointSpec{`,
		`Outputs:` + repeatedStringForOutputs + `,`,
		`Probe:` + strings.Replace(this.Probe.String(), "Probe", "Probe", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *BPFTrace) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&BPFTrace{`,
		`Program:` + fmt.Sprintf("%v", this.Program) + `,`,
		`}`,
	}, "")
	return s
}
func (this *UPID) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&UPID{`,
		`Asid:` + fmt.Sprintf("%v", this.Asid) + `,`,
		`Pid:` + fmt.Sprintf("%v", this.Pid) + `,`,
		`TsNs:` + fmt.Sprintf("%v", this.TsNs) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DeploymentSpec) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DeploymentSpec{`,
		`TargetOneof:` + fmt.Sprintf("%v", this.TargetOneof) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DeploymentSpec_Upid) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DeploymentSpec_Upid{`,
		`Upid:` + strings.Replace(fmt.Sprintf("%v", this.Upid), "UPID", "UPID", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DeploymentSpec_SharedObject_) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DeploymentSpec_SharedObject_{`,
		`SharedObject:` + strings.Replace(fmt.Sprintf("%v", this.SharedObject), "DeploymentSpec_SharedObject", "DeploymentSpec_SharedObject", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DeploymentSpec_PodProcess_) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DeploymentSpec_PodProcess_{`,
		`PodProcess:` + strings.Replace(fmt.Sprintf("%v", this.PodProcess), "DeploymentSpec_PodProcess", "DeploymentSpec_PodProcess", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DeploymentSpec_LabelSelector_) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DeploymentSpec_LabelSelector_{`,
		`LabelSelector:` + strings.Replace(fmt.Sprintf("%v", this.LabelSelector), "DeploymentSpec_LabelSelector", "DeploymentSpec_LabelSelector", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DeploymentSpec_SharedObject) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DeploymentSpec_SharedObject{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Upid:` + strings.Replace(this.Upid.String(), "UPID", "UPID", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DeploymentSpec_PodProcess) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DeploymentSpec_PodProcess{`,
		`Pods:` + fmt.Sprintf("%v", this.Pods) + `,`,
		`Container:` + fmt.Sprintf("%v", this.Container) + `,`,
		`Process:` + fmt.Sprintf("%v", this.Process) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DeploymentSpec_LabelSelector) String() string {
	if this == nil {
		return "nil"
	}
	keysForLabels := make([]string, 0, len(this.Labels))
	for k, _ := range this.Labels {
		keysForLabels = append(keysForLabels, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForLabels)
	mapStringForLabels := "map[string]string{"
	for _, k := range keysForLabels {
		mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k])
	}
	mapStringForLabels += "}"
	s := strings.Join([]string{`&DeploymentSpec_LabelSelector{`,
		`Labels:` + mapStringForLabels + `,`,
		`Namespace:` + fmt.Sprintf("%v", this.Namespace) + `,`,
		`Container:` + fmt.Sprintf("%v", this.Container) + `,`,
		`Process:` + fmt.Sprintf("%v", this.Process) + `,`,
		`}`,
	}, "")
	return s
}
func (this *TracepointSelector) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&TracepointSelector{`,
		`SelectorType:` + fmt.Sprintf("%v", this.SelectorType) + `,`,
		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
		`}`,
	}, "")
	return s
}
func (this *TracepointDeployment) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForPrograms := "[]*TracepointDeployment_TracepointProgram{"
	for _, f := range this.Programs {
		repeatedStringForPrograms += strings.Replace(fmt.Sprintf("%v", f), "TracepointDeployment_TracepointProgram", "TracepointDeployment_TracepointProgram", 1) + ","
	}
	repeatedStringForPrograms += "}"
	s := strings.Join([]string{`&TracepointDeployment{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`TTL:` + strings.Replace(fmt.Sprintf("%v", this.TTL), "Duration", "types.Duration", 1) + `,`,
		`DeploymentSpec:` + strings.Replace(this.DeploymentSpec.String(), "DeploymentSpec", "DeploymentSpec", 1) + `,`,
		`Programs:` + repeatedStringForPrograms + `,`,
		`}`,
	}, "")
	return s
}
func (this *TracepointDeployment_TracepointProgram) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForSelectors := "[]*TracepointSelector{"
	for _, f := range this.Selectors {
		repeatedStringForSelectors += strings.Replace(f.String(), "TracepointSelector", "TracepointSelector", 1) + ","
	}
	repeatedStringForSelectors += "}"
	s := strings.Join([]string{`&TracepointDeployment_TracepointProgram{`,
		`TableName:` + fmt.Sprintf("%v", this.TableName) + `,`,
		`Spec:` + strings.Replace(this.Spec.String(), "TracepointSpec", "TracepointSpec", 1) + `,`,
		`BPFTrace:` + strings.Replace(this.BPFTrace.String(), "BPFTrace", "BPFTrace", 1) + `,`,
		`Selectors:` + repeatedStringForSelectors + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringLogical(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *Argument) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLogical
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Argument: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Argument: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Expr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Expr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLogical(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLogical
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ReturnValue) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLogical
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ReturnValue: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ReturnValue: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Expr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Expr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLogical(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLogical
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Output) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLogical
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Output: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Output: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fields", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Fields = append(m.Fields, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLogical(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLogical
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *OutputAction) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLogical
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: OutputAction: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OutputAction: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OutputName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OutputName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VariableNames", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.VariableNames = append(m.VariableNames, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLogical(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLogical
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Tracepoint) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLogical
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Tracepoint: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Tracepoint: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Symbol", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Symbol = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLogical(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLogical
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FunctionLatency) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLogical
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: FunctionLatency: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FunctionLatency: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLogical(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLogical
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Probe) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLogical
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Probe: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Probe: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tracepoint", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Tracepoint == nil {
				m.Tracepoint = &Tracepoint{}
			}
			if err := m.Tracepoint.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Args", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Args = append(m.Args, &Argument{})
			if err := m.Args[len(m.Args)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RetVals", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RetVals = append(m.RetVals, &ReturnValue{})
			if err := m.RetVals[len(m.RetVals)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FunctionLatency", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &FunctionLatency{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.FunctionLatencyOneof = &Probe_FunctionLatency{v}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OutputActions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OutputActions = append(m.OutputActions, &OutputAction{})
			if err := m.OutputActions[len(m.OutputActions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLogical(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLogical
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TracepointSpec) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLogical
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TracepointSpec: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TracepointSpec: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Outputs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Outputs = append(m.Outputs, &Output{})
			if err := m.Outputs[len(m.Outputs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Probe", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Probe == nil {
				m.Probe = &Probe{}
			}
			if err := m.Probe.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLogical(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLogical
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BPFTrace) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLogical
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: BPFTrace: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BPFTrace: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Program", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Program = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLogical(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLogical
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UPID) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLogical
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: UPID: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UPID: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Asid", wireType)
			}
			m.Asid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Asid |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pid", wireType)
			}
			m.Pid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Pid |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TsNs", wireType)
			}
			m.TsNs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TsNs |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipLogical(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLogical
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DeploymentSpec) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLogical
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DeploymentSpec: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeploymentSpec: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Upid", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &UPID{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.TargetOneof = &DeploymentSpec_Upid{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SharedObject", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &DeploymentSpec_SharedObject{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.TargetOneof = &DeploymentSpec_SharedObject_{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PodProcess", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &DeploymentSpec_PodProcess{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.TargetOneof = &DeploymentSpec_PodProcess_{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LabelSelector", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &DeploymentSpec_LabelSelector{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.TargetOneof = &DeploymentSpec_LabelSelector_{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLogical(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLogical
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DeploymentSpec_SharedObject) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLogical
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SharedObject: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SharedObject: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Upid", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Upid == nil {
				m.Upid = &UPID{}
			}
			if err := m.Upid.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLogical(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLogical
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DeploymentSpec_PodProcess) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLogical
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PodProcess: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PodProcess: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pods", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Pods = append(m.Pods, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Container", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Container = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Process", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Process = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLogical(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLogical
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DeploymentSpec_LabelSelector) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLogical
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: LabelSelector: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LabelSelector: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Labels == nil {
				m.Labels = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowLogical
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowLogical
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthLogical
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthLogical
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowLogical
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthLogical
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthLogical
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipLogical(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthLogical
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Labels[mapkey] = mapvalue
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Container", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Container = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Process", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Process = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLogical(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLogical
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TracepointSelector) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLogical
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TracepointSelector: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TracepointSelector: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SelectorType", wireType)
			}
			m.SelectorType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SelectorType |= SelectorType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Value = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLogical(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLogical
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TracepointDeployment) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLogical
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TracepointDeployment: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TracepointDeployment: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TTL", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TTL == nil {
				m.TTL = &types.Duration{}
			}
			if err := m.TTL.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeploymentSpec", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DeploymentSpec == nil {
				m.DeploymentSpec = &DeploymentSpec{}
			}
			if err := m.DeploymentSpec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Programs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Programs = append(m.Programs, &TracepointDeployment_TracepointProgram{})
			if err := m.Programs[len(m.Programs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLogical(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLogical
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TracepointDeployment_TracepointProgram) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLogical
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TracepointProgram: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TracepointProgram: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TableName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TableName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Spec == nil {
				m.Spec = &TracepointSpec{}
			}
			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BPFTrace", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.BPFTrace == nil {
				m.BPFTrace = &BPFTrace{}
			}
			if err := m.BPFTrace.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Selectors", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Selectors = append(m.Selectors, &TracepointSelector{})
			if err := m.Selectors[len(m.Selectors)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLogical(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLogical
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipLogical(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowLogical
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthLogical
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupLogical
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthLogical
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthLogical        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowLogical          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupLogical = fmt.Errorf("proto: unexpected end of group")
)
